home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / circuits / irsim-ca.2 / irsim-ca / irsim-cap-9.2 / src / irsim / patchfile < prev    next >
Text File  |  1995-05-29  |  11KB  |  428 lines
  1. 23,24c23,24
  2. < #define    LSIZE        2000    /* max size of command line (in chars) */
  3. < #define    MAXARGS        100    /* maximum number of command-line arguments */
  4. ---
  5. > #define    LSIZE        1000000    /* max size of command line (in chars) */
  6. > #define    MAXARGS        50000    /* maximum number of command-line arguments */
  7. 38a39,43
  8. > /* Don't skimp on the space here PLEASE. It causes problems on
  9. > machines where a -short- is just 16 bits (most machines) */
  10. > #if 1
  11. >     int        nmin, nmax;        /* min and max number of arguments */
  12. > #else
  13. 39a45
  14. > #endif
  15. 100a107
  16. > public    int    count_InTrans = FALSE;    /* count INPUT trans. (PEL 4/20/93) */
  17. 103a111,112
  18. > public    FILE    *caplogfile = NULL;    /* log file of cap transitions */
  19. > public    float    totpower = 0;        /* indicative of total power of chip */
  20. 371c380
  21. <     for( i = 0, s = "0ux1lUXhLUXH"; s[i] != '\0'; i++ )
  22. ---
  23. >     for( i = 0, s = "0ux1lUXhHUXL"; s[i] != '\0'; i++ )
  24. 800a810,835
  25. > /*
  26. >  * set/clear captrace bit in node
  27. >  */
  28. > private int xcaptrace( n, flag )
  29. >   nptr  n;
  30. >   char  *flag;
  31. >   {
  32. >     UnAlias( n );
  33. > 
  34. >     if( n->nflags & MERGED )
  35. >       {
  36. >     lprintf( stdout, "can't trace %s\n", pnode( n ) );
  37. >     return( 1 );
  38. >       }
  39. > 
  40. >     if( *flag == '+' )
  41. >     n->nflags |= CAPWATCHED;
  42. >     else if( n->nflags & CAPWATCHED )
  43. >       {
  44. >     lprintf( stdout, "%s was capwatched; not any more\n", pnode( n ) );
  45. >     n->nflags &= ~CAPWATCHED;
  46. >       }
  47. > 
  48. >     return( 1 );
  49. >   }
  50. > 
  51. 821a857,876
  52. > /*
  53. >  * set/clear captrace bit in vector
  54. >  */
  55. > private int vcaptrace( b, flag )
  56. >   register bptr  b;
  57. >   char           *flag;
  58. >   {
  59. >     register int   i;
  60. > 
  61. >     if( *flag == '+' )
  62. >     b->traced |= CAPWATCHVECTOR;
  63. >     else
  64. >       {
  65. >     for( i = 0; i < b->nbits; i += 1 )
  66. >         b->nodes[i]->nflags &= ~CAPWATCHVECTOR;
  67. >     b->traced &= ~CAPWATCHVECTOR;
  68. >       }
  69. >     return( 1 );
  70. >   }
  71. > 
  72. 893a949,1065
  73. >  * Set flag that determines whether transitions on primary inputs will
  74. >  * contribute to overall transition count used to determine total
  75. >  * capacitance charged.  (PEL 5/4/93)
  76. >  */
  77. > private int setinputcap()
  78. >   {
  79. >     if( targc == 1 )
  80. >       {
  81. >     lprintf( stdout, "input capacitance transition accumulator is %s\n",
  82. >       (count_InTrans) ? "ON" : "OFF" );
  83. >     return( 0 );
  84. >       }
  85. > 
  86. >     if( str_eql( "on", targv[1] ) == 0 )
  87. >     count_InTrans = TRUE;
  88. >     else if( str_eql( "off", targv[1] ) == 0 )
  89. >     count_InTrans = FALSE;
  90. >     else
  91. >     error( filename, lineno, "don't know what '%s' means\n", targv[1] );
  92. > 
  93. >     return( 0 );
  94. >   }
  95. > 
  96. > 
  97. > /*
  98. >  * mark nodes and vectors for cap tracing
  99. >  */
  100. > private int setcaptrace()
  101. >   {
  102. >     apply( xcaptrace, vcaptrace, plus_minus );
  103. >     set_vec_nodes( CAPWATCHVECTOR );
  104. >     return( 0 );
  105. >   }
  106. > 
  107. > 
  108. > /*
  109. >  * Helper routine for summing capacitance
  110. >  */
  111. > private int sumcapdoit( n, capsum )
  112. >   register nptr  n;
  113. >   float *capsum;
  114. >   {
  115. >     /* Don't UnAlias() before checking if it's an ALIAS node (PEL 5/31/93) */
  116. >     /* UnAlias( n ); */
  117. > 
  118. >     if( not (n->nflags & (MERGED | ALIAS)) )
  119. >     {
  120. >        *capsum += n->ncap;
  121. >        lprintf( stdout, "%-35s\t\%f\n", pnode( n ), n->ncap);
  122. >     }
  123. > 
  124. >     return( 0 );
  125. >   }
  126. > 
  127. > /*
  128. >  * Helper routine for summing capacitance
  129. >  */
  130. > private int sumcapdoit_eff( n, capsum )
  131. >   register nptr  n;
  132. >   float *capsum;
  133. >   {
  134. >     if ( not (n->nflags & (MERGED | ALIAS)) )
  135. >     *capsum += n->ncap;
  136. >     if( VDD_node != NULL and str_eql( pnode( n ) , pnode( VDD_node ) ) == 0 )
  137. >     *capsum -= n->ncap;
  138. >     if( GND_node != NULL and str_eql( pnode( n ) , pnode( GND_node ) ) == 0 )
  139. >     *capsum -= n->ncap;
  140. > 
  141. >     return( 0 );
  142. >   }
  143. > 
  144. > /*
  145. >  * Print sum of capacitance of nodes
  146. >  */
  147. > private int sumcap()
  148. >   {
  149. >     float capsum = 0;
  150. >     lprintf( stdout, "\nNode \t\t\t\t\t Capacitance (pF)\n" );
  151. >     walk_net( sumcapdoit, (char *) &capsum );
  152. >     lprintf( stdout, "\n Sum of nodal capacitances (including Gnd and Vdd): %f pF",capsum );
  153. > 
  154. >     capsum = 0;
  155. > 
  156. >     walk_net( sumcapdoit_eff, (char *) &capsum );
  157. >     lprintf( stdout, "\n Sum of nodal capacitances: %f pF \n",capsum );
  158. > 
  159. >     return( 0 );
  160. >   }
  161. > 
  162. > 
  163. > /*
  164. >  * Helper routine for zeroing transition counts (PEL 4/30/93). 
  165. >  * Zeros even MERGE and ALIAS node transition counts since this can't
  166. >  * hurt anything.
  167. >  */
  168. > private int zeropowerdoit( n )
  169. >   register nptr  n;
  170. >   {
  171. >     n->trans = 0;
  172. >     n->trans01 = 0.0;    /* PEL 5/3/93 */
  173. > 
  174. >     return( 0 );
  175. >   }
  176. > 
  177. > 
  178. > /*
  179. >  * Zero totpower and transition counts for all nodes (PEL 4/30/93)
  180. >  */
  181. > private int zeropower()
  182. >   {
  183. >     walk_net( zeropowerdoit, (char *) 0 );
  184. >     totpower = 0;
  185. >     return( 0 );
  186. >   }
  187. > 
  188. > 
  189. > /*
  190. 1052,1053c1224,1225
  191. <     if( val == X_X ) val = X;
  192. <     if( n->npot != val )
  193. ---
  194. > 
  195. >     if( n->npot != (val == X_X) ? X : val )
  196. 1858a2031,2032
  197. > public
  198. > #define    REPORT_CAP    0x10
  199. 1866c2040
  200. <     static char  *rep[] = { "decay", "delay", "tau", "tcoord", NULL };
  201. ---
  202. >     static char  *rep[] = { "decay", "delay", "tau", "tcoord", "cap", NULL };
  203. 1920a2095,2281
  204. > /*
  205. >  * Helper routine for printing capacitance totals.
  206. >  */
  207. > 
  208. > private int capsummer( n )
  209. >   register nptr  n;
  210. >   {
  211. >     /* Don't UnAlias() before checking if it's an ALIAS node (PEL 5/31/93) */
  212. >     /* UnAlias( n ); */
  213. > 
  214. >     if( not (n->nflags & (MERGED | ALIAS)) )
  215. >     {
  216. >     lprintf( stdout, " %-35s\t%.3f\t%5d\t%f\t%f\n", 
  217. >         pnode( n ), 
  218. >         n->ncap, 
  219. >         n->trans, 
  220. >         n->trans*n->ncap, 
  221. >         n->trans*n->ncap / totpower);
  222. >     }
  223. >     return( 0 );
  224. >   }
  225. > 
  226. > /*
  227. >  * set up or finish off logfile
  228. >  */
  229. > private int setcaplog()
  230. >   {
  231. >     if( caplogfile != NULL )
  232. >       {
  233. >     (void) fclose( caplogfile );
  234. >     caplogfile = NULL;
  235. >     walk_net( capsummer, (char *) 0 );
  236. >       }
  237. > 
  238. >     if( targc == 2 )
  239. >       {
  240. >     char  *mode = "w";
  241. >     char  *s = targv[1];
  242. > 
  243. >     if( *s == '+' )
  244. >       {
  245. >         s++;
  246. >         mode = "a";
  247. >       }
  248. >     if( (caplogfile = fopen( s, mode )) == NULL )
  249. >     error( filename, lineno, "cannot open log file %s for output\n", s );
  250. >       }
  251. >     return( 0 );
  252. >   }
  253. > 
  254. > /*
  255. >  * Helper routine for capreport().  For a given node, print capacitive node
  256. >  * transition count.  Include node even if it is an ALIAS'd node.  Use nodal
  257. >  * 'naliases' count to distribute node capacitances equally across all
  258. >  * equivalent nodes. (PEL 5/28/93)
  259. >  */ 
  260. > private int capreportdoit( n, CapReportFile )
  261. >   register nptr  n;
  262. >   FILE *CapReportFile;
  263. >   {
  264. >     nptr  root = n;
  265. > 
  266. >     UnAlias( root );
  267. > 
  268. >     if( not (n->nflags & MERGED) )
  269. >       {
  270. >         lprintf( CapReportFile, " %-35s\t%5d\t%.3f\t%f\t%f\n", pnode( n ),
  271. >           root->naliases+1,
  272. >           root->ncap/(root->naliases+1),
  273. >           root->trans01,
  274. >           root->trans01*root->ncap/(root->naliases+1));
  275. >       }
  276. >     return( 0 );
  277. >   }
  278. > 
  279. > /*
  280. >  * Print report of all capacitive node transition counts.  Report includes
  281. >  * all nodes including ALIAS'd nodes.  Capacitances are distributed equally
  282. >  * across all equivalent nodes. (PEL 5/28/93)
  283. >  */ 
  284. > private int capreport()
  285. >   {
  286. >     FILE  *CapReportFile = NULL;    /* file of effective caps. */
  287. > 
  288. >     if( targc == 1 )
  289. >       {
  290. >         walk_net( capreportdoit, (char *) stdout );
  291. >       }
  292. >     else
  293. >       {
  294. >         char  *mode = "w";
  295. >         char  *s = targv[1];
  296. >         if( *s == '+' )
  297. >           {
  298. >             s++;
  299. >             mode = "a";
  300. >           }
  301. >         if( (CapReportFile = fopen( s, mode )) == NULL )
  302. >               error( filename, lineno,
  303. >                  "cannot open capreport file %s for output\n", s );
  304. >         walk_net( capreportdoit, (char *) CapReportFile );
  305. >         fclose( CapReportFile );
  306. >       }
  307. >     return( 0 );
  308. >   }
  309. > 
  310. > /*
  311. >  * Helper routine to compute total capacitance charged.  For a given
  312. >  * node, computes the physical capacitance of that node weighted by the number
  313. >  * of 0->1 transitions on that node, and adds this value to the total
  314. >  * capacitance charged. (PEL 5/3/93)
  315. >  */
  316. > private int effcapsummer( n, capsum )
  317. >   register nptr  n;
  318. >   float *capsum;
  319. >   {
  320. >     char  *nname = pnode( n );
  321. >     char  *is_merge;
  322. > 
  323. >     /* Don't UnAlias() before checking if it's an ALIAS node (PEL 5/31/93) */
  324. >     /* UnAlias( n ); */
  325. > 
  326. >     if( not (n->nflags & (MERGED | ALIAS)) )
  327. >       {
  328. >     *capsum += n->trans01*n->ncap;
  329. >       }
  330. >     return( 0 );
  331. >   }
  332. > 
  333. > /*
  334. >  * Compute the total cap charged.  That is, sum the physical capacitance
  335. >  * of each node weighted by the number of 0->1 transitions on that node
  336. >  * (PEL 5/4/93)
  337. >  */
  338. > private int sumeffcap()
  339. >   {
  340. >     FILE  *CapChgdFile = NULL;    /* file of effective caps. */
  341. >     float capsum = 0;
  342. > 
  343. >     walk_net( effcapsummer, (char *) &capsum );
  344. >     if( targc == 1 )
  345. >       {
  346. >     lprintf( stdout, "Total capacitance charged: %f pF\n", capsum );
  347. >       }
  348. >     else
  349. >       {
  350. >         char  *mode = "w";
  351. >         char  *s = targv[1];
  352. >         if( *s == '+' )
  353. >           {
  354. >             s++;
  355. >             mode = "a";
  356. >           }
  357. >         if( (CapChgdFile = fopen( s, mode )) == NULL )
  358. >           error( filename, lineno, "cannot open cap file %s for output\n", s );
  359. >         fprintf( CapChgdFile, "Total capacitance charged: %f pF\n", capsum );
  360. >         fclose( CapChgdFile );
  361. >       }
  362. >     return( 0 );
  363. >   }
  364. > 
  365. > 
  366. > /*
  367. >  * Output message to file. (PEL 10/7/93)
  368. >  */
  369. > private int dofmsg()
  370. >   {
  371. >     FILE  *MsgFile = NULL;  /* target file for message */
  372. >     int  n;
  373. > 
  374. >     char  *mode = "w";
  375. >     char  *s = targv[1];
  376. >     if( *s == '+' )
  377. >       {
  378. >         s++;
  379. >         mode = "a";
  380. >       }
  381. >     if( (MsgFile = fopen( s, mode )) == NULL )
  382. >       error( filename, lineno, "cannot open file %s for comment\n", s );
  383. > 
  384. >     for( n = 2; n < targc; n += 1 )
  385. >     fprintf( MsgFile, "%s ", targv[n] );
  386. >     fprintf( MsgFile, "\n" );
  387. >     fclose( MsgFile );
  388. >     return( 0 );
  389. >   }
  390. > 
  391. 2158c2519,2520
  392. <     UnAlias( n );
  393. ---
  394. >     /* Don't UnAlias() before checking if it's an ALIAS node (PEL 5/31/93) */
  395. >     /* UnAlias( n ); */
  396. 2217c2579,2580
  397. <     UnAlias( n );
  398. ---
  399. >     /* Don't UnAlias() before checking if it's an ALIAS node (PEL 5/31/93) */
  400. >     /* UnAlias( n ); */
  401. 3384a3708,3723
  402. >     { "caplogfile",    setcaplog,    1,    2,
  403. >       "[[+]file] -> start/stop cap logfile (+file appends to file)"    },
  404. >     { "captrace",    setcaptrace,    2,    MAXARGS,
  405. >       "[-]node/vector... -> start/stop cap tracing specified node/vector(s)"},
  406. >     { "sumcap",        sumcap,        1,    2,
  407. >       "print out sum of capacitances of all nodes"            },
  408. >     { "zeropower",    zeropower,    1,    1,    /* (PEL 4/30/93) */
  409. >       " -> zero current power estimate and nodal transition counts"    },
  410. >     { "sumeffcap",    sumeffcap,    1,    2,    /* (PEL 5/4/93) */
  411. >       "[[+]file] -> output total effective capacitance charged from 0->1"},
  412. >     { "inputcap",    setinputcap,    1,    2,    /* (PEL 5/4/93) */
  413. >       "[on | off] -> enable/disable cap. contribs. from transitions on inputs"},
  414. >     { "capreport",    capreport,    1,    2,    /* (PEL 5/28/93) */
  415. >       "[[+]file] -> report cap. node trans. distributed over all node aliases"},
  416. >     { "fprint",        dofmsg,        2,    MAXARGS, /* (PEL 10/7/93) */
  417. >       "[+]file [text...] -> output specified text to file"},
  418. 3435c3774
  419. <     (void) fprintf( stderr, "[-s] prm_file {sim_file ..} [-cmd_file ..]\n" );
  420. ---
  421. >     (void) fprintf( stderr,"[-s] prm_file {sim_file ..} [-cmd_file ..]\n" );
  422. 3481c3820
  423. <     (void) fprintf( stdout, "*** IRSIM %s ***\n", version );
  424. ---
  425. >     (void) fprintf( stdout, "*** IRSIM-CAP %s ***\n", version );
  426. 3550a3890
  427. > 
  428.